home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / primitives / mapping.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  15.6 KB  |  505 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from funcs import isiterable
  5. from functional import AttrChain
  6. from itertools import tee
  7.  
  8. def fmt_to_dict(delim1, delim2):
  9.     
  10.     class dictifier('dictifier', (dict,)):
  11.         
  12.         def __init__(self, *a, **k):
  13.             if a and isinstance(a[0], basestring):
  14.                 dict.__init__(self, self.parse(a[0]), *a[1:], **k)
  15.             else:
  16.                 dict.__init__(self, *a, **k)
  17.  
  18.         
  19.         def parse(cls, s):
  20.             return (tuple,)((lambda .0: for entry in .0:
  21. entry.strip().split(delim2, 1))(s.split(delim1)))
  22.  
  23.         parse = (None, classmethod)(parse)
  24.         
  25.         def __str__(self):
  26.             return (delim1.join,)((lambda .0: for i in .0:
  27. delim2.join(i))(self.items()))
  28.  
  29.  
  30.     return dictifier
  31.  
  32.  
  33. def dictreverse(mapping):
  34.     return dict((lambda .0: for key, value in .0:
  35. (value, key))(mapping.iteritems()))
  36.  
  37.  
  38. def dictadd(dict_a, dict_b):
  39.     result = dict(dict_a)
  40.     result.update(dict_b)
  41.     return result
  42.  
  43.  
  44. def dictsub(a, b):
  45.     a = a.copy()
  46.     for key in b:
  47.         a.pop(key, None)
  48.     
  49.     return a
  50.  
  51.  
  52. def dictdiff(defaults, user):
  53.     diff = { }
  54.     for k, v in user.iteritems():
  55.         if k not in defaults or v != defaults[k]:
  56.             diff[k] = v
  57.             continue
  58.     
  59.     return diff
  60.  
  61.  
  62. def intdictdiff(start, end):
  63.     keys = set(start.keys()) | set(end.keys())
  64.     out = { }
  65.     for key in keys:
  66.         startval = start.get(key, 0)
  67.         endval = end.get(key, 0)
  68.         outval = endval - startval
  69.         if outval:
  70.             out[key] = outval
  71.             continue
  72.     
  73.     return out
  74.  
  75.  
  76. class DictChain(AttrChain, dict):
  77.     
  78.     def __init__(self, *args, **kwargs):
  79.         dict.__init__(self, *args, **kwargs)
  80.         AttrChain.__init__(self, 'base', self.__getattr2__)
  81.  
  82.     
  83.     def __getattr2__(self, key):
  84.         keys = None if isinstance(key, basestring) else key
  85.         next = self[keys[0]]
  86.         if len(keys) > 1 and isinstance(next, DictChain):
  87.             return dict.__getattribute__(next, '__getattr2__')(keys[1:])
  88.         elif keys:
  89.             
  90.             try:
  91.                 returner = next
  92.             except:
  93.                 return self['generic'][keys[0]]
  94.  
  95.             if isinstance(returner, DictChain):
  96.                 return returner['value']
  97.             else:
  98.                 return returner
  99.         else:
  100.             return self['value']
  101.  
  102.  
  103.  
  104. class Storage(dict):
  105.     
  106.     def __getattr__(self, key, ga = dict.__getattribute__, gi = dict.__getitem__):
  107.         
  108.         try:
  109.             return ga(self, key)
  110.         except AttributeError:
  111.             
  112.             try:
  113.                 return gi(self, key)
  114.             except KeyError:
  115.                 msg = repr(key)
  116.                 if len(self) <= 20:
  117.                     keys = sorted(self.keys())
  118.                     msg += '\n  (%d existing keys: ' % len(keys) + str(keys) + ')'
  119.                 
  120.                 raise AttributeError, msg
  121.             except:
  122.                 None<EXCEPTION MATCH>KeyError
  123.             
  124.  
  125.             None<EXCEPTION MATCH>KeyError
  126.  
  127.  
  128.     
  129.     def __setattr__(self, key, value):
  130.         self[key] = value
  131.  
  132.     
  133.     def copy(self):
  134.         return type(self)(self)
  135.  
  136.  
  137. Storage.__module__ = 'util.primitives'
  138.  
  139. def dictrecurse(newtype):
  140.     
  141.     def recurser(_d, forbidden = (None, ())):
  142.         if not hasattr(_d, 'keys'):
  143.             pformat = pformat
  144.             import pprint
  145.             raise TypeError('what is?\n%s' % pformat(_d))
  146.         
  147.         for k in _d:
  148.             if isinstance(_d[k], dict):
  149.                 _d[k] = recurser(_d[k])
  150.                 continue
  151.             if isiterable(_d[k]) and not isinstance(_d[k], forbidden + (basestring,)):
  152.                 _d[k] = (list,)((lambda .0: for item in .0:
  153. None if isinstance(item, dict) else item)(_d[k]))
  154.                 continue
  155.         
  156.         if isinstance(newtype, type):
  157.             return None if isinstance(_d, newtype) else newtype(_d)
  158.         else:
  159.             return newtype(_d)
  160.  
  161.     return recurser
  162.  
  163. to_storage = dictrecurse(Storage)
  164.  
  165. def from_storage(d):
  166.     for k, v in d.items():
  167.         if isinstance(v, Storage):
  168.             d[k] = from_storage(v)
  169.             continue
  170.         if isinstance(v, list):
  171.             newlist = [ _[1] if isinstance(e, Storage) else e for e in d[k] ]
  172.             d[k] = newlist
  173.             continue
  174.         []
  175.     
  176.     return None if type(d) is dict else dict(d)
  177.  
  178.  
  179. def lookup_table(*a, **d):
  180.     d = dict(*a, **d)
  181.     d.update(dictreverse(d))
  182.     return to_storage(d)
  183.  
  184.  
  185. class no_case_dict(dict):
  186.     
  187.     def __getitem__(self, attr, get = dict.__getitem__):
  188.         return get(self, attr.lower())
  189.  
  190.     
  191.     def __setitem__(self, attr, val):
  192.         return dict.__setitem__(self, attr.lower(), val)
  193.  
  194.     
  195.     def __delitem__(self, key):
  196.         return dict.__delitem__(self, key.lower())
  197.  
  198.     
  199.     def __contains__(self, attr):
  200.         return dict.__contains__(self, attr.lower())
  201.  
  202.     
  203.     def setdefault(self, attr, default):
  204.         
  205.         try:
  206.             return dict.__getitem__(self, attr.lower())
  207.         except KeyError:
  208.             dict.__setitem__(self, attr.lower(), default)
  209.             return default
  210.  
  211.  
  212.     
  213.     def pop(self, k, x = None):
  214.         return dict.pop(self, k.lower(), x)
  215.  
  216.  
  217.  
  218. def stringify_dict(dict):
  219.     new = { }
  220.     for k, v in dict.items():
  221.         if isinstance(k, basestring):
  222.             new[str(k)] = v
  223.             continue
  224.         new[k] = v
  225.     
  226.     return new
  227.  
  228.  
  229. class odict(dict):
  230.     
  231.     def __init__(self, d = None):
  232.         if d is None:
  233.             d = { }
  234.         
  235.         
  236.         try:
  237.             t = d.items()
  238.             self._keys = [ k for k, _v in t ]
  239.             dict.__init__(self, t)
  240.         except:
  241.             (one, two, three) = tee(d, 3)
  242.             
  243.             try:
  244.                 self._keys = [ k for k, _v in one ]
  245.             except:
  246.                 self._keys = [ k for k in two ]
  247.  
  248.             [](dict.__init__, self if isinstance(d, dict) else three)
  249.  
  250.  
  251.     
  252.     def __delitem__(self, key):
  253.         dict.__delitem__(self, key)
  254.         self._keys.remove(key)
  255.  
  256.     
  257.     def __setitem__(self, key, item):
  258.         dict.__setitem__(self, key, item)
  259.         if not hasattr(self, '_keys'):
  260.             self._keys = [
  261.                 key]
  262.         
  263.         if key not in self._keys:
  264.             self._keys.append(key)
  265.         
  266.  
  267.     __iter__ = property((lambda self: self._keys.__iter__))
  268.     
  269.     def clear(self):
  270.         dict.clear(self)
  271.         self._keys = []
  272.  
  273.     
  274.     def pop(self, k, defval = sentinel):
  275.         
  276.         try:
  277.             val = dict.pop(self, k)
  278.         except KeyError:
  279.             if defval is sentinel:
  280.                 raise 
  281.             else:
  282.                 return defval
  283.         except:
  284.             defval is sentinel
  285.  
  286.         self._keys.remove(k)
  287.         return val
  288.  
  289.     
  290.     def iteritems(self):
  291.         for i in self._keys:
  292.             
  293.             try:
  294.                 yield (i, self[i])
  295.             continue
  296.             except KeyError:
  297.                 print 'fake keys', self._keys
  298.                 print 'real keys', self.keys()
  299.                 raise 
  300.                 continue
  301.             
  302.  
  303.         
  304.  
  305.     
  306.     def items(self):
  307.         return list(self.iteritems())
  308.  
  309.     
  310.     def keys(self):
  311.         return self._keys
  312.  
  313.     
  314.     def popitem(self):
  315.         if len(self._keys) == 0:
  316.             raise KeyError('dictionary is empty')
  317.         else:
  318.             key = self._keys[-1]
  319.             val = self[key]
  320.             del self[key]
  321.             return (key, val)
  322.  
  323.     
  324.     def setdefault(self, key, failobj = None):
  325.         ret = dict.setdefault(self, key, failobj)
  326.         if key not in self._keys:
  327.             self._keys.append(key)
  328.         
  329.         return ret
  330.  
  331.     
  332.     def update(self, d):
  333.         
  334.         try:
  335.             for key in d.keys():
  336.                 if not self.has_key(key):
  337.                     self._keys.append(key)
  338.                     continue
  339.         except AttributeError:
  340.             for k, v in d:
  341.                 self[k] = v
  342.             
  343.             return None
  344.  
  345.         dict.update(self, d)
  346.  
  347.     
  348.     def values(self):
  349.         for i in self._keys:
  350.             yield self[i]
  351.         
  352.  
  353.     
  354.     def move(self, key, index):
  355.         
  356.         try:
  357.             cur = self._keys.index(key)
  358.         except ValueError:
  359.             raise KeyError(key)
  360.  
  361.         self._keys.insert(index, key)
  362.         if cur >= index:
  363.             cur = cur + 1
  364.         
  365.         del self._keys[cur]
  366.  
  367.     
  368.     def index(self, key):
  369.         if not self.has_key(key):
  370.             raise KeyError(key)
  371.         
  372.         return self._keys.index(key)
  373.  
  374.  
  375.  
  376. class LazySortedDict(odict):
  377.     
  378.     def _get_keys(self):
  379.         
  380.         try:
  381.             self._real_keys = sorted(self._real_keys)
  382.         except AttributeError:
  383.             self._real_keys = []
  384.  
  385.         return self._real_keys
  386.  
  387.     
  388.     def _set_keys(self, keys):
  389.         self._real_keys = sorted(keys)
  390.  
  391.     
  392.     def copy(self):
  393.         return type(self)(self)
  394.  
  395.     _keys = property(_get_keys, _set_keys)
  396.  
  397.  
  398. class ostorage(odict, Storage):
  399.     
  400.     def __getattr__(self, attr):
  401.         if attr == '_keys':
  402.             return odict.__getattr__(self, '_keys')
  403.         else:
  404.             return Storage.__getattr__(self, attr)
  405.  
  406.     
  407.     def __setattr__(self, attr, val):
  408.         if attr == '_keys':
  409.             return odict.__setattr__(self, attr, val)
  410.         else:
  411.             return Storage.__setattr__(self, attr, val)
  412.  
  413.  
  414.  
  415. def groupify(seq, keys = None, whitelist = True, mapclass = odict):
  416.     retval = [
  417.         mapclass()]
  418.     idx = 0
  419.     for k, v in seq:
  420.         if keys and whitelist ^ (k in keys):
  421.             continue
  422.         
  423.         if k in retval[idx]:
  424.             retval.append(mapclass())
  425.             idx += 1
  426.         
  427.         retval[idx][k] = v
  428.     
  429.     if not retval[0]:
  430.         return []
  431.     
  432.     return retval
  433.  
  434.  
  435. class FilterDict(dict):
  436.     
  437.     def __init__(self, filterfunc, d = None, **kw):
  438.         if d is None:
  439.             d = { }
  440.         
  441.         dict.__init__(self)
  442.         d.update(kw)
  443.         dict.__setattr__(self, 'ff', filterfunc)
  444.         for k, v in d.iteritems():
  445.             self.__setitem__(k, v)
  446.         
  447.  
  448.     
  449.     def __getitem__(self, key):
  450.         return dict.__getitem__(self, self.ff(key))
  451.  
  452.     
  453.     def __delitem__(self, key):
  454.         return dict.__delitem__(self, self.ff(key))
  455.  
  456.     
  457.     def __contains__(self, key):
  458.         return dict.__contains__(self, self.ff(key))
  459.  
  460.     
  461.     def __setitem__(self, key, newval):
  462.         return dict.__setitem__(self, self.ff(key), newval)
  463.  
  464.  
  465.  
  466. class LowerDict(FilterDict):
  467.     
  468.     def __init__(self, *a, **k):
  469.         
  470.         def filterfunc(x):
  471.             
  472.             try:
  473.                 x = x.lower()
  474.             except:
  475.                 pass
  476.  
  477.             return x
  478.  
  479.         FilterDict.__init__(self, filterfunc, *a, **k)
  480.  
  481.  
  482. recurse_lower = dictrecurse(LowerDict)
  483.  
  484. class LowerStorage(LowerDict, Storage):
  485.     
  486.     def __init__(self, *a, **k):
  487.         Storage.__init__(self)
  488.         LowerDict.__init__(self, *a, **k)
  489.  
  490.  
  491. recurse_lower_storage = dictrecurse(LowerStorage)
  492.  
  493. def odict_from_dictlist(seq):
  494.     od = odict()
  495.     for subdict in seq:
  496.         key = subdict.keys()[0]
  497.         od[key] = subdict[key]
  498.     
  499.     return od
  500.  
  501. if __name__ == '__main__':
  502.     import doctest
  503.     doctest.testmod(verbose = True)
  504.  
  505.